import { ecs } from "db://oops-framework/libs/ecs/ECS";
import { Role } from "../../../../role/Role";
import { Skill } from "../../Skill";
import { Buff } from "../../../buff/Buff";
import { oops } from "db://oops-framework/core/Oops";
import { BuffCasting } from "../../../buff/bll/content/BuffCasting";
import { EffectBuff } from "../../model/report/EffectBuff";

/** BUFF类效果 */
export class RoleBuff {
    /** 所有人某种buff的数量 */
    static buffConf: any = {};

    // 重置指定id的buff配置
    static resetBuffConf(id: number) {
        // 如果存在指定id的buff配置
        if (RoleBuff.buffConf[id]) {
            // 将最大值和数量重置为0
            RoleBuff.buffConf[id].max = 0;
            RoleBuff.buffConf[id].num = 0;
        }
    }

     // 静态方法，用于增加指定id的buff的最大值
     static addNum(id: number) {
        // 判断指定id的buff是否存在
        if (RoleBuff.buffConf[id]) {
            // 如果存在，则将最大值加1
            RoleBuff.buffConf[id].max += 1;
        } else {
            // 如果不存在，则创建一个新的buff，初始值为0，最大值为1
            RoleBuff.buffConf[id] = { num: 0, max: 1 };
        }
    }

       /** 一次攻击同类型所有buff都添加完 */
    // 判断是否所有buff都已添加
    static isAllAdded(id: number): number {
        // 将指定id的buff数量加1
        RoleBuff.buffConf[id].num += 1;
        // 如果指定id的buff数量大于等于最大数量，则返回最大数量
        if (RoleBuff.buffConf[id].num >= RoleBuff.buffConf[id].max) {
            return RoleBuff.buffConf[id].max
        // 否则返回0
        } else {
            return 0;
        }
    }

       /**
     * 获取BUFF唯一标识
     * @param id    BUFF编号
     * @param skill 技能编号
     * @returns 技能编号_BUFF编号
     */
    // 根据id和技能获取key
    static getKey(id: number, skill: Skill): string {
        // 返回技能模型id和id的拼接字符串
        return `${skill.SkillModel.id}_${id}`;
    }

        /**
     * 添加BUFF效果
     * @param caster 技能施放者
     * @param target 技能受击者
     * @param skill  施放BUFF的技能
     * @param config BUFF效果的数值配置{round:1, id:1, value: 1}
     * @param isBuffTrigger 是否为BUFF触发的BUFF效果
     */
    static add(caster: Role, target: Role, skill: Skill, config: any, isBuffTrigger: boolean = false): EffectBuff {
        // 如果没有目标，则返回空BUFF
        if (!target) {
            return new EffectBuff();
        }
        // 获取BUFF的ID
        var buffId = config.id;
        // 获取BUFF的持续时间
        var round = config.round;
        // 获取BUFF的key
        var key = RoleBuff.getKey(buffId, skill);
        // 获取目标身上的BUFF
        var buff = target.RoleModelBattle.buffs.get(key);
        // 定义BUFF的施放
        var casting: BuffCasting;
        // 定义是否添加成功
        var isAdded: boolean = true;

        // 添加新BUFF
        if (buff == null) {
            // 获取BUFF实体
            buff = ecs.getEntity<Buff>(Buff);
            // 设置BUFF的ID
            buff.BuffModel.id = buffId;
            // 设置BUFF的施放者
            buff.BuffModel.caster = caster;
            // 设置BUFF的目标
            buff.BuffModel.target = target;
            // 设置BUFF的技能
            buff.BuffModel.skill = skill;
            // 设置BUFF的叠加层数
            buff.BuffModel.overlying = 1;
            // 设置BUFF的持续时间
            buff.BuffModel.round = round;
            // 设置BUFF是否永久
            buff.BuffModel.forever = round == -1;
            // 设置BUFF的配置
            buff.BuffModel.config = config;

            // 获取BUFF的施放
            casting = buff.BuffModel.casting;
            // 设置BUFF的施放
            casting.buff = buff;

            // 将BUFF添加到目标身上
            target.RoleModelBattle.buffs.set(key, buff);
            // 设置添加成功
            isAdded = true;
        }
        // 覆盖BUFF
        else {
            // 获取BUFF的施放
            casting = buff.BuffModel.casting;

            // 添加同类BUFF时，重置持续时间
            buff.BuffModel.round = round;

            // BUFF覆盖：持续时间刷新、层数增加（记录在策划配置表中）
            if (buff.BuffModel.overlying < buff.BuffModel.table.overlying) buff.BuffModel.overlying++;

            // 设置添加失败
            isAdded = false;
        }

        // 战报：BUFF添加
        var effect = new EffectBuff();
        effect.addto = true;
        effect.buff = buff;
        if (isBuffTrigger) {
            // 如果是BUFF触发，则调用BUFF的施放
            buff.BuffModel.casting.hit(target, effect);
        }
        else {
            // 否则调用技能的施放
            skill.SkillModel.casting.hit(target, effect);
        }

        if (isAdded) {
            // BUFF添加完成时触发
            casting.onAdded();
        } else {
            // 战斗事件：BUFF覆盖或叠加时触发
            casting.onCover();
        }
        // 返回效果
        return effect;
    }

     // 静态方法，移除控制类buff
     static removeKongzhiBuffs(target: Role) {
        // 遍历目标角色的buff
        target.RoleModelBattle.buffs.forEach((buff, key) => {
            // 如果buff的id为2、3或4，则移除该buff
            if (buff.BuffModel.id == 2 || buff.BuffModel.id == 3 || buff.BuffModel.id == 4) {
                this.removeByBuffId(target, key);
            }
        });
    }

        /**
    * 移除指定BUFF
    * @param target 技能受击者
    * @param buffId 施放BUFF的编号
    */
        static removeByBuffId(target: Role, buffId: string): EffectBuff {
            var buff = target.RoleModelBattle.buffs.get(buffId);
            if (buff) {
                return this.remove(target, buff);
            }
            return null!;
        }

         /** BUFF持续时间结束 */
    // 静态方法，移除指定角色的指定buff
    static remove(target: Role, buff: Buff, isBuffTrigger: boolean = true): EffectBuff {
        // 调用buff的移除方法
        buff.BuffModel.casting.onRemove();
        // 记录日志
        oops.log.logBusiness(`【${target.RoleModel.uuid}】移除buff【${buff.BuffModel.table.name}】【${buff.BuffModel.id}】`);
        // 从角色的buff列表中删除该buff
        target.RoleModelBattle.buffs.delete(buff.BuffModel.key);
        // 创建一个新的EffectBuff对象
        var effect = new EffectBuff();
        // 设置addto属性为false
        effect.addto = false;
        // 设置buff属性为传入的buff
        effect.buff = buff;
        // 调用buff的销毁方法
        buff.destroy();
        // 返回EffectBuff对象
        return effect;
    }

     /** 移除目标所有BUFF */
     static removeAllBuff(target: Role) {
        var buffs = target.RoleModelBattle.buffs;
        buffs.forEach(buff => {
            this.remove(target, buff);
        });
        buffs.clear();
    }

      /** 更新BUFF持续回合 */
      static update(target: Role) {
        var buffs = target.RoleModelBattle.buffs;

        buffs.forEach(buff => {
            // 非永久BUFF每次行动完后，减少一次持续回合，当回合数为零时移除BUFF状态
            if (!buff.BuffModel.forever) {
                // 减少一回合持续时间
                if (buff.BuffModel.round > 0) {
                    buff.BuffModel.round--;
                }
                // 持续时间为零时，删除BUFF
                if (buff.BuffModel.round == 0) {
                    this.remove(target, buff);
                }
            }
        });
    }
}